home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: delta / whiteline CD Series - delta.iso / progtool / c / egem_210 / egem / source / xacc_av.c < prev   
C/C++ Source or Header  |  1995-11-25  |  10KB  |  577 lines
  1.  
  2. #include "proto.h"
  3. #include <string.h>
  4. #include <time.h>
  5.  
  6. #define ACC_TEXT_WAIT    2000
  7. #define ACC_IMG_WAIT    4000
  8. #define ACC_META_WAIT    4000
  9.  
  10. int AvServer=-1,_xacc_msgs;
  11. static char *XAccName,*AVName,a_name[9];
  12. static int av_msgs,va_msgs,multi_xacc=FALSE;
  13. static XAcc Xaccs[MAX_XACCS];
  14.  
  15. static void    store_xacc_id(int*);
  16. static void    store_av_id(int*,int,int);
  17. static void    kill_id(int);
  18.  
  19. static void    XAccSendId(int);
  20. static void    XAccSendAcc(int);
  21. static void XAccSendAccClose(void);
  22. static int XAccWait(int,int);
  23.  
  24. int appl_search(int ap_smode,char *ap_sname,int *ap_stype,int *ap_sid)
  25. {
  26.     INTIN[0] = ap_smode;
  27.     ADDRIN[0] = ap_sname;
  28.     _aes(0,0x12010301L);
  29.  
  30.     *ap_stype = INTOUT[1];
  31.     *ap_sid = INTOUT[2];
  32.  
  33.     return (INTOUT[0]);
  34. }
  35.  
  36. int AvSendMsg(int sendto,int msg_id,int *msg)
  37. {
  38.     if (sendto>=0)
  39.     {
  40.         msg[0] = msg_id;
  41.         msg[1] = ap_id;
  42.         msg[2] = 0;
  43.  
  44.         if (appl_write(sendto,16,msg)>0)
  45.             return (TRUE);
  46.         else if (sendto!=ap_id)
  47.             kill_id(sendto);
  48.     }
  49.  
  50.     return (FALSE);
  51. }
  52.  
  53. static int XAccSend(int sendto,int msg0,int msg3,char *msg4,int msg6,int msg7)
  54. {
  55.     if (sendto>=0 && sendto!=ap_id)
  56.     {
  57.         int msg[8];
  58.  
  59.         msg[0] = msg0;
  60.         msg[1] = ap_id;
  61.         msg[2] = 0;
  62.         msg[3] = msg3;
  63.         *(char **) &msg[4] = msg4;
  64.         msg[6] = msg6;
  65.         msg[7] = msg7;
  66.  
  67.         if (appl_write(sendto, 16, msg)>0)
  68.             return (TRUE);
  69.         else
  70.             kill_id(sendto);
  71.     }
  72.  
  73.     return (FALSE);
  74. }
  75.  
  76. int XAccSendAck(int sendto, int answer)
  77. {
  78.     return (XAccSend(sendto,ACC_ACK,(answer) ? 1 : 0,NULL,0,0));
  79. }
  80.  
  81. int XAccSendText(int sendto, char *text)
  82. {
  83.     if (XAccSend(sendto, ACC_TEXT, 0, text, 0, 0)==TRUE)
  84.         return (XAccWait(sendto,ACC_TEXT_WAIT));
  85.     else
  86.         return (FALSE);
  87. }
  88.  
  89. int XAccSendKey(int sendto, int scan, int state)
  90. {
  91.     if (XAccSend(sendto, ACC_KEY, scan, (char *) (((long) state)<<16), 0, 0)==TRUE)
  92.         return (TRUE);
  93.     else
  94.         return (FALSE);
  95. }
  96.  
  97. int XAccSendMeta(int sendto, int last, char *data, long len)
  98. {
  99.     if (XAccSend(sendto, ACC_META, (last) ? 1: 0, data, (int) (len>>16), (int) len)==TRUE)
  100.         return (XAccWait(sendto,ACC_META_WAIT));
  101.     else
  102.         return (FALSE);
  103. }
  104.  
  105. int XAccSendImg(int sendto, int last, char *data, long len)
  106. {
  107.     if (XAccSend(sendto, ACC_IMG, (last) ? 1: 0, data, (int) (len>>16), (int) len)==TRUE)
  108.         return (XAccWait(sendto,ACC_IMG_WAIT));
  109.     else
  110.         return (FALSE);
  111. }
  112.  
  113. static void XAccSendId(int sendto)
  114. {
  115.     XAccSend(sendto, ACC_ID, (XACCVERSION<<8)|XACC_LEVEL, XAccName, menu_id, 0);
  116. }
  117.  
  118. static void XAccSendAcc(int sendto)
  119. {
  120.     XAccSend(sendto, ACC_ACC, (XACCVERSION<<8)|XACC_LEVEL, XAccName, menu_id, ap_id);
  121. }
  122.  
  123. void _XAccAvExit(void)
  124. {
  125.     reg XAcc *xacc;
  126.     reg int i;
  127.     int msg[8];
  128.  
  129.     if (multi_xacc)
  130.     {
  131.         msg[3] = ap_id;
  132.  
  133.         for (i=0,xacc=Xaccs;i<MAX_XACCS;xacc++,i++)
  134.         {
  135.             if (multi && (xacc->flag & AV))
  136.                 AvSendMsg(xacc->id,AV_EXIT,msg);
  137.  
  138.             if (xacc->flag & XACC)
  139.                 AvSendMsg(xacc->id,ACC_EXIT,msg);
  140.         }
  141.     }
  142. }
  143.  
  144. static void XAccInformAcc(int *msg)
  145. {
  146.     reg XAcc *xacc;
  147.     reg char *name = *((char **) &msg[4]);
  148.     reg int i;
  149.  
  150.     for (i=0,xacc=Xaccs;i<MAX_XACCS;xacc++,i++)
  151.         if (xacc->flag & XACC)
  152.             XAccSend(xacc->id,ACC_ACC,msg[3],name,msg[6],msg[1]);
  153. }
  154.  
  155. int AppLoaded(char *app)
  156. {
  157.     reg char buf[9], *p;
  158.     reg int i,id;
  159.  
  160.     if (app==NULL)
  161.         return (-1);
  162.  
  163.     p = GetFilename(app);
  164.     for (i=0;i<8;i++)
  165.         if(*p>' ' && *p!='.')
  166.             buf[i] = *p++;
  167.         else
  168.             buf[i] = ' ';
  169.     buf[8] = '\0';
  170.  
  171.     id = appl_find(buf);
  172.     if (id==ap_id)
  173.         id = -1;
  174.  
  175.     return (id);
  176. }
  177.  
  178. void XAccBroadCast(int *msg)
  179. {
  180.     int info,dummy;
  181.  
  182.     if (aes_version>=0x0400 || (appl_xgetinfo(10,&info,&dummy,&dummy,&dummy) && (info & 0xff)>=7))
  183.     {
  184.         msg[1] = ap_id;
  185.         msg[2] = 0;
  186.         shel_write(7,0,0,(char *) msg,NULL);
  187.     }
  188.     else if (search)
  189.     {
  190.         char name[10];
  191.         int next,type,id;
  192.  
  193.         next = 0;
  194.         while (appl_search(next, name, &type, &id))
  195.         {
  196.             if (id!=ap_id && (type & 0x06))
  197.                 AvSendMsg(id,msg[0],msg);
  198.             next = 1;
  199.         }
  200.     }
  201.     else
  202.     {
  203.         reg XAcc *xacc;
  204.         reg int i;
  205.  
  206.         for (i=0,xacc=Xaccs;i<MAX_XACCS;xacc++,i++)
  207.             if (xacc->id>=0)
  208.                 AvSendMsg(xacc->id,msg[0],msg);
  209.     }
  210. }
  211.  
  212. void *GetMsgBuffer(long size)
  213. {
  214.     if (mint || magx)
  215.         return (Mxalloc(size,0x0023));
  216.     else
  217.         return (Malloc(size));
  218. }
  219.  
  220. void _XAccSendStartup(char *xacc_name, char *av_name, int Avmsgs,int Vamsgs, int xacc_msgs)
  221. {
  222.     reg char name[10], *buf, *p;
  223.     int xacc_size,av_size;
  224.     int i,next,type,id;
  225.  
  226.     XAccName = p = xacc_name;
  227.  
  228.     while (*p++);
  229.     if (!stricmp(p,"XDSC"))
  230.     {
  231.         do
  232.         {
  233.             while (*p++);
  234.         } while (*p++);
  235.     }
  236.  
  237.     xacc_size = (int) (p - xacc_name);
  238.  
  239.     strcpy(a_name,"        ");
  240.     AVName = memcpy(a_name,av_name,min((int) strlen(av_name),8));
  241.     av_size = 8+1;
  242.  
  243.     av_msgs = Avmsgs|MSG_START;
  244.     va_msgs = Vamsgs|MSG_EXIT|MSG_SENDKEY|MSG_ACCWINDOPEN|MSG_PATH_UPDATE;
  245.     _xacc_msgs = xacc_msgs;
  246.  
  247.     for (i=0;i<MAX_XACCS;i++)
  248.         Xaccs[i].id = -1;
  249.  
  250.     if ((buf=GetMsgBuffer(xacc_size+av_size))!=NULL)
  251.     {
  252.         XAccName = memcpy(buf, XAccName, xacc_size);
  253.         buf += xacc_size;
  254.         AVName = memcpy(buf, AVName, av_size);
  255.     }
  256.  
  257.     if (search)
  258.     {
  259.         multi_xacc = TRUE;
  260.  
  261.         next = 0;
  262.         while (appl_search(next, name, &type, &id))
  263.         {
  264.             if (id!=ap_id && (type & 0x06))
  265.                 XAccSendId(id);
  266.             next = 1;
  267.         }
  268.     }
  269.  
  270.     if (multi)
  271.     {
  272.         id = AppLoaded(getenv("AVSERVER"));
  273.         if (id<0)
  274.             id = AppLoaded("AVSERVER");
  275.         if (id<0)
  276.             id = AppLoaded("GEMINI");
  277.  
  278.         if (id==ap_id)
  279.             AvServer = -1;
  280.         else
  281.             AvServer = id;
  282.     }
  283.     else if (!_app)
  284.         XAccSendAccClose();
  285.     evnt_timer(250,0);
  286. }
  287.  
  288. static int XAccWait(int ap_id,int wait)
  289. {
  290.     XEVENT event;
  291.     reg int *msg = event.ev_mmgpbuf;
  292.  
  293.     memset(&event,0,sizeof(XEVENT));
  294.     event.ev_mflags = MU_MESAG|MU_TIMER;
  295.     event.ev_mtlocount = wait;
  296.  
  297.     while (Event_Multi(&event)==MU_MESAG)
  298.     {
  299.         switch (msg[0])
  300.         {
  301.         case ACC_ACK:
  302.             if (ap_id==msg[1])
  303.                 return((msg[3]==1) ? TRUE : FALSE);
  304.             break;
  305.         case AC_OPEN:
  306.         case AC_CLOSE:
  307.             if (_app)
  308.                 break;
  309.         case AP_TERM:
  310.             return (FALSE);
  311.         }
  312.     }
  313.  
  314.     return(FALSE);
  315. }
  316.  
  317. static void AvProtocol(int id)
  318. {
  319.     int msg[8];
  320.  
  321.     if (id!=ap_id)
  322.     {
  323.         msg[3] = av_msgs;
  324.         msg[4] = msg[5] = 0;
  325.         *(const char **) &msg[6] = AVName;
  326.         AvSendMsg(id,AV_PROTOKOLL,msg);
  327.     }
  328. }
  329.  
  330. static void AvProtoStatus(int id)
  331. {
  332.     int msg[8];
  333.  
  334.     if (id!=AvServer && id!=ap_id)
  335.     {
  336.         msg[3] = va_msgs;
  337.         msg[4] = msg[5] = 0;
  338.         *(const char **) &msg[6] = AVName;
  339.         AvSendMsg(id,VA_PROTOSTATUS,msg);
  340.     }
  341. }
  342.  
  343. static void XAccSendAccClose(void)
  344. {
  345.     kill_id(0);
  346.     AvServer = -1;
  347.     XAccSendId(0);
  348.     AvProtocol(0);
  349. }
  350.  
  351. int _XAccComm(int *msg)
  352. {
  353.     reg int id = msg[1];
  354.  
  355.     switch (msg[0])
  356.     {
  357.     case AC_CLOSE:
  358.         if (!_app && !multi)
  359.             XAccSendAccClose();
  360.         return (FALSE);
  361.     case ACC_ACC:
  362.         if (multi_xacc)
  363.         {
  364.             if (msg[7]<=0 || id==msg[7])
  365.             {
  366.                 if (multi)
  367.                 {
  368.                     AvProtocol(id);
  369.                     AvProtoStatus(id);
  370.                 }
  371.                 store_xacc_id(msg);
  372.             }
  373.         }
  374.         else if (!_app)
  375.         {
  376.             msg[1] = msg[7];
  377.             XAccSendId(msg[1]);
  378.             store_xacc_id(msg);
  379.         }
  380.         break;
  381.     case ACC_ID:
  382.         if (multi_xacc)
  383.         {
  384.             XAccSendAcc(id);
  385.             if (multi)
  386.             {
  387.                 AvProtocol(id);
  388.                 AvProtoStatus(id);
  389.             }
  390.         }
  391.         else if (_app)
  392.         {
  393.             XAccInformAcc(msg);
  394.             XAccSendId(id);
  395.         }
  396.         store_xacc_id(msg);
  397.         break;
  398.     case AV_EXIT:
  399.         kill_id(msg[3]);
  400.         break;
  401.     case ACC_EXIT:
  402.         kill_id(id);
  403.         break;
  404.     case CH_EXIT:
  405.         kill_id(msg[3]);
  406.         return (FALSE);
  407.     case AV_PROTOKOLL:
  408.         AvProtoStatus(id);
  409.         store_av_id(msg,msg[3],FAIL);
  410.         break;
  411.     case VA_PROTOSTATUS:
  412.         store_av_id(msg,FAIL,msg[3]);
  413.         break;
  414.     default:
  415.         return (FALSE);
  416.     }
  417.  
  418.     return (TRUE);
  419. }
  420.  
  421. static void store_av_id(int *msg,int av_msgs,int va_msgs)
  422. {
  423.     reg XAcc *xacc=Xaccs;
  424.     reg int id=msg[1],i;
  425.     char shell[9];
  426.     int type,sh_id;
  427.  
  428.     if (id==ap_id || id<0)
  429.         return;
  430.  
  431.     for (i=0;i<MAX_XACCS && xacc->id>=0;xacc++,i++)
  432.         if (xacc->id==id)
  433.             break;
  434.  
  435.     if (i<MAX_XACCS)
  436.     {
  437.         if (id==0 && !_app && !multi)
  438.             AvServer = 0;
  439.         else if (AvServer<0 && search && multi)
  440.             if (appl_search(2,shell,&type,&sh_id) && sh_id==id)
  441.                 AvServer = id;
  442.  
  443.         xacc->flag |= AV;
  444.         xacc->id = id;
  445.  
  446.         strncpy(xacc->name,*((char **) &msg[6]),8);
  447.  
  448.         if (av_msgs!=FAIL)
  449.             xacc->av_msgs = av_msgs;
  450.         if (va_msgs!=FAIL)
  451.             xacc->va_msgs = va_msgs;
  452.  
  453.         _send_msg(xacc,id,XACC_AV_INIT,0,0);
  454.     }
  455. }
  456.  
  457. static void store_xacc_id(int *msg)
  458. {
  459.     reg XAcc *xacc;
  460.     reg int id=msg[1],i;
  461.     reg char *xdsc;
  462.  
  463.     if (id==ap_id || id<0)
  464.         return;
  465.  
  466.     for (i=0,xacc=Xaccs;i<MAX_XACCS && xacc->id>=0;xacc++,i++)
  467.         if (xacc->id==id)
  468.             break;
  469.  
  470.     if (i<MAX_XACCS)
  471.     {
  472.         xacc->flag |= XACC;
  473.  
  474.         xacc->id = id;
  475.         xacc->version = msg[3];
  476.         xacc->menu_id = msg[6];
  477.         xacc->xname = *((char **) &msg[4]);
  478.         xacc->xdsc = NULL;
  479.         if (xacc->xname!=NULL)
  480.         {
  481.             xdsc = xacc->xname + strlen(xacc->xname)+1;
  482.             if (!strcmp(xdsc,"XDSC"))
  483.                 xacc->xdsc = xdsc+5;
  484.         }
  485.  
  486.         _send_msg(xacc,id,XACC_AV_INIT,0,0);
  487.     }
  488. }
  489.  
  490. static void kill_id(int id)
  491. {
  492.     reg XAcc *xacc;
  493.     reg int i;
  494.  
  495.     if (id<0)
  496.         return;
  497.  
  498.     for (i=0,xacc=Xaccs;i<MAX_XACCS;xacc++,i++)
  499.         if (id==xacc->id)
  500.         {
  501.             memset(xacc,0,sizeof(XAcc));
  502.             xacc->id = -1;
  503.  
  504.             if (id==AvServer)
  505.                 AvServer = -1;
  506.  
  507.             _send_msg(xacc,id,XACC_AV_EXIT,0,0);
  508.             return;
  509.         }
  510. }
  511.  
  512. XAcc *find_xacc_xdsc(int id,char *dsc)
  513. {
  514.     reg XAcc *xacc;
  515.     reg char *xdsc;
  516.     reg int i;
  517.  
  518.     for (i=0,xacc=Xaccs;i<MAX_XACCS;xacc++,i++)
  519.         if (xacc->id>=0 && (id<0 || xacc->id==id))
  520.         {
  521.             if ((xdsc=xacc->xdsc)!=NULL)
  522.             {
  523.                 while (*xdsc!='\0')
  524.                 {
  525.                     if (!strcmp(xdsc,dsc))
  526.                         return (xacc);
  527.                     xdsc += strlen(xdsc)+1;
  528.                 }
  529.             }
  530.  
  531.             if (xacc->id==id)
  532.                 break;
  533.         }
  534.  
  535.     return (NULL);
  536. }
  537.  
  538. static int next=-1;
  539.  
  540. XAcc *find_app(int first)
  541. {
  542.     reg XAcc *xacc;
  543.     reg int i;
  544.  
  545.     if (first)
  546.         i = 0;
  547.     else if (next<0 || next>=MAX_XACCS)
  548.         return (NULL);
  549.     else
  550.         i = next;
  551.  
  552.     for (xacc=&Xaccs[i];i<MAX_XACCS;xacc++,i++)
  553.         if (xacc->id>=0)
  554.         {
  555.             next = i+1;
  556.             return (xacc);
  557.         }
  558.  
  559.     next = -1;
  560.     return (NULL);
  561. }
  562.  
  563. XAcc *find_id(int id)
  564. {
  565.     reg XAcc *xacc;
  566.     reg int i;
  567.  
  568.     if (id<0)
  569.         return (NULL);
  570.  
  571.     for (i=0,xacc=Xaccs;i<MAX_XACCS;xacc++,i++)
  572.         if (xacc->id==id)
  573.             return (xacc);
  574.  
  575.     return (NULL);
  576. }
  577.